class Food {

}
class Fruit extends Food {

}
class Apple extends Fruit {

}
class Banana extends Fruit {

}

class Plate<T> {
	private T plate ;

	public T getPlate() {
		return plate;
	}

	public void setPlate(T plate) {
		this.plate = plate;
	}
}
class Message<T> {
	private T message;

	public T getMessage() {
		return message;
	}

	public void setMessage(T message) {
		this.message = message;
	}
}
public class Test {
	//这就是泛型
	public static void fun(Message<?> temp) {
		System.out.println(temp.getMessage());
	}

	/**
	 * 通配符的上界不能进行数据的写入，只能读取数据
	 * @param temp
	 */
	public static void funExtends(Message<? extends Fruit> temp) {
		System.out.println(temp.getMessage());
		//发生向上转型
		//这个参数只要是Fruit的子类或者是Fruit都可以
		//传过去的是一个对象，把这个对象当作自己的message
		//通配符的上界来说，无法修改数据是因为temp存储的是他的子类或者是本身的
		//分不清楚是哪个，所以不允许来进行修改数据，只能进行读取数据
		//temp.setMessage(new Banana());
		Fruit fruit=temp.getMessage();
	}
	//可以传入的是Fruit类型或者是Fruit的父类类型
	public static void funSuper(Plate<? super Fruit> temp) {
		//此时可以修改，因为Apple是参数子类，或者是本身
		//可能会发生向上转型
		temp.setPlate(new Apple());
		temp.setPlate(new Fruit());
		//Fruit fruit=temp.getPlate();
		//这里不能进行读取数据，因为不知道父类是谁
		//只能进行输出
		System.out.println(temp.getPlate());
	}

	public static void main(String[] args) {
		Plate<Fruit> plate=new Plate<>();
		Plate<Food> plate1=new Plate<>();
		funSuper(plate);
		funSuper(plate1);
	}
	public static void main2(String[] args) {
		Message<Apple> message=new Message<>();
		message.setMessage(new Apple());
		Message<Banana> message1=new Message<>();
		message1.setMessage(new Banana());
		funExtends(message);
		funExtends(message1);
	}
	public static void main1(String[] args) {
		Message<String > message=new Message<>();
		message.setMessage("hello");
		fun(message);

		Message<Integer> message1=new Message<>();
		message1.setMessage(180);
		fun(message1);
	}
}
